import { bus } from "@/bus";
import { loadConfig } from '@/config.ts'
import { ActionLogOta } from "@/entity/actionLogOta.entity";  // 导入 ActionLogOta 实体
import { Gateway } from "@/entity/gateway.entity";
import { DataSource } from "typeorm";
import * as state from './state'
import { Wristband } from "@/entity/wristband.entity";
import { createAdv } from "./persist/wristbandAdv";
import { saveLastAdv } from "./persist/wristbandLastAdv"
import { WristbandAdv } from "@/entity/wristband_adv.entity";
import { WristbandAdvLast } from "@/entity/wristband_adv_last.entity";
import { updateGw } from "./persist/gateway";
import { updateWristband } from "./persist/wristband";
import * as XlsxPopulate from 'xlsx-populate'; // 引入 xlsx-populate
import { PythonShell } from 'python-shell'; // 引入 python-shell

// 定义每分钟统计数据的接口
interface MinuteStats {
  count: number;      // 广播次数
  avgRssi: number;    // 平均RSSI
}
let lowFrequencyStats: {
  minute: string;
  count: number;
  macList: string[];
}[] = [];

let gatewayMaxWristbands: { [gatewayMac: string]: number } = {};
let allTimeMax = 0;
let allTimeMaxGateway = '';

export async function setup() {
  let conf = await loadConfig();

  let macCount: { [key: string]: { count: number, rssiSum: number } } = {};
  let lastTimestamp = Date.now();
  let minuteCounter = 0; // 当前分钟计数器(0-4)
  // 存储每个MAC地址的滑动窗口统计数据
  const slidingWindowStats: { [key: string]: MinuteStats[] } = {};

  bus.on('wb.adv.decode', async (pack: any) => {
    const currentTimestamp = Date.now();
    const currentWristbandCount = pack.wb_adv.length;
    const gatewayMac = pack.mac;
    const gw = {
      mac: pack.mac,
      version_bin: pack.frm_ver.split('/')[0],
      version_fs: pack.frm_ver.split('/')[1],
      time: new Date(),
      last_report_time: new Date(),
      last_report_wb_cnt: pack.wb_adv.length,
      deleted: false,
      outdoor: false,
    };

    const wbArray = pack.wb_adv.map((item: any) => {
      return {
        addr: item.mac.toUpperCase(),
        rssi: item.rssi | 1000000000,
        idx: item.idx,
        beacon1: item.beacon1,
        beacon2: item.beacon2,
        beacon3: item.beacon3,
        acc_x: 0,
        acc_y: 0,
        acc_z: 0,
        motion: item.motion || 0,
        motion_variance: item.motion_variance || 0,
        steps: item.steps,
        hr: item.hr,
        hrv: item.hrv,
        hr_confidence: item.hr_confidence,
        temperature: item.temp,
        bat_vol: item.bat_vol,
        charging: item.charging,
        wear_on: item.wear_on,
        req_rt: item.req_rt,
        fake_hr: item.fake_hr,
        time: new Date(),
        format: item.format_ver,
        version: item.firmware_ver,
        name: 'c1',
        deleted: false,
      };
    });

    // 更新单个网关的最大携带数
    if (!gatewayMaxWristbands[gatewayMac] || currentWristbandCount > gatewayMaxWristbands[gatewayMac]) {
      gatewayMaxWristbands[gatewayMac] = currentWristbandCount;

      // 更新全局最大值
      if (currentWristbandCount > allTimeMax) {
        allTimeMax = currentWristbandCount;
        allTimeMaxGateway = gatewayMac;
      }
    }

    // 统计每个MAC的出现次数和RSSI总和
    wbArray.forEach((item: any) => {
      if (!macCount[item.addr]) {
        macCount[item.addr] = { count: 0, rssiSum: 0 };
      }
      macCount[item.addr].count += 1;
      macCount[item.addr].rssiSum += item.rssi;
    });

    // 每分钟统计一次
    if (currentTimestamp - lastTimestamp > 60 * 1000) {
      // 统计出现频率小于10的手环
      const lowFrequencyMacs = Object.entries(macCount)
        .filter(([_, { count }]) => count < 10)
        .map(([mac]) => mac);

      // 记录当前分钟的低频统计
      const currentMinute = new Date().toISOString().slice(11, 16); // 格式: "HH:MM"
      lowFrequencyStats.push({
        minute: currentMinute,
        count: lowFrequencyMacs.length,
        macList: lowFrequencyMacs
      });

      // 保持只记录最近60分钟的数据
      if (lowFrequencyStats.length > 60) {
        lowFrequencyStats.shift();
      }

      const sortedMacs = Object.entries(macCount)
        .filter(([mac, { count }]) => count >= 0)
        .sort((a, b) => b[0].localeCompare(a[0]))
        .map(([mac, { count, rssiSum }]) => ({
          mac,
          count,
          avgRssi: rssiSum / count,
        }));


      // 生成 Excel 并插入图表
      // async function exportWithChart(sortedMacs: any[]) {
      //   try {
      //     let workbook;
      //     const filePath = './wristband_stats_with_chart.xlsx';

      //     try {
      //       // 如果文件存在则加载
      //       workbook = await XlsxPopulate.fromFileAsync(filePath);
      //     } catch {
      //       // 文件不存在则创建新工作簿
      //       workbook = await XlsxPopulate.fromBlankAsync();
      //     }

      //     // 2. 添加新工作表（按分钟命名）
      //     const sheetName = `Stats_${new Date().toISOString().slice(0, 16).replace(/:/g, '-')}`;
      //     const sheet = workbook.addSheet(sheetName);

      //     // 3. 插入表头和数据
      //     sheet.cell("A1").value("排名");
      //     sheet.cell("B1").value("手环MAC");
      //     sheet.cell("C1").value("出现次数");
      //     sheet.cell("D1").value("平均RSSI");

      //     sortedMacs.forEach((entry, index) => {
      //       sheet.cell(`A${index + 2}`).value(index + 1);
      //       sheet.cell(`B${index + 2}`).value(entry.mac);
      //       sheet.cell(`C${index + 2}`).value(entry.count);
      //       sheet.cell(`D${index + 2}`).value(Number(entry.avgRssi.toFixed(2)));
      //     });

      //     // 4. 保存 Excel 文件后，调用 Python 脚本插入图表
      //     await workbook.toFileAsync(filePath);
      //     console.log(`数据已保存到 ${filePath}`);


      //     // 使用 Python 插入图表
      //     // 使用 Promise 的方式来运行 Python 脚本
      //     // async function runPythonScript() {
      //     //   try {
      //     //     const result = await PythonShell.run('insert_chart.py', { args: [filePath] });
      //     //     console.log('Python 脚本输出:', result);
      //     //   } catch (err) {
      //     //     console.error('Python 脚本运行失败:', err);
      //     //   }
      //     // }

      //     // 调用函数
      //     // runPythonScript();
      //   } catch (err) {
      //     console.error("导出Excel失败:", err);
      //   }
      // }

      // await exportWithChart(sortedMacs);

      // 对所有MAC地址进行处理
      Object.keys(macCount).forEach(mac => {
        if (!slidingWindowStats[mac]) {
          // 初始化5分钟的滑动窗口数组
          slidingWindowStats[mac] = Array(5).fill({ count: 0, avgRssi: 0 });
        }

        // 计算当前分钟的统计数据
        const currentStats = {
          count: macCount[mac].count,
          avgRssi: macCount[mac].rssiSum / macCount[mac].count
        };

        // 滑动窗口左移：删除最旧的数据(索引0)，在末尾添加新数据
        slidingWindowStats[mac].shift(); // 移除第一个元素
        slidingWindowStats[mac].push(currentStats); // 添加新元素到末尾
      });
      // 打印统计结果（合并到原有的每分钟打印中）
      printMinuteStats(sortedMacs, lowFrequencyMacs.length, lowFrequencyMacs);

      printGatewayCapacityStats();

      // 每5分钟打印一次完整统计数据
      if (minuteCounter === 4) {
        printSlidingWindowStats();
      }

      // 更新分钟计数器(0-4循环)
      minuteCounter = (minuteCounter + 1) % 5;

      // 重置统计，开始新一分钟的计数
      macCount = {};
      lastTimestamp = currentTimestamp;
    }
  });

  // 打印滑动窗口统计数据
  function printSlidingWindowStats() {
    console.log('\n===== 滑动窗口手环统计数据(最新数据在最右边) =====');

    Object.entries(slidingWindowStats).forEach(([mac, stats], index) => {
      // 确保总是有5分钟的数据
      const paddedStats = stats.length >= 5 ? stats : [
        ...Array(5 - stats.length).fill({ count: 0, avgRssi: 0 }),
        ...stats
      ];

      // 格式化输出行
      const line = [
        `${index + 1}\t`,
        `[${mac}]\t`,
        ...paddedStats.flatMap(stat => [
          `${stat.count.toString().padStart(2)}\t`,
          `${stat.avgRssi.toFixed(2).padStart(7)}\t`,
          '|'
        ])
      ].join('  ');

      console.log(line);
    });
    // 添加低频统计摘要
    const last5MinLowFreq = lowFrequencyStats.slice(-5);
    console.log('\n过去5分钟低频手环(<10次)统计:');
    last5MinLowFreq.forEach(stat => {
      console.log(`${stat.minute}: ${stat.count}个`);
    });
    console.log('==================================================\n');
  }
}


function printGatewayCapacityStats() {
  console.log('\n===== 网关携带手环数量统计 =====');
  console.log(`历史最大携带数: ${allTimeMax} (网关: ${allTimeMaxGateway})`);

  // 按携带数量降序排序
  const sortedGateways = Object.entries(gatewayMaxWristbands)
    .sort((a, b) => b[1] - a[1]);

  // 打印每个网关的最大携带数
  sortedGateways.forEach(([mac, max]) => {
    console.log(`网关 ${mac}: 最大携带 ${max} 个手环`);
  });

  console.log('===============================\n');
}


function printMinuteStats(sortedMacs: any[], lowFrequencyCount: number, lowFrequencyMacs: string[]) {
  console.log('\n===== 分钟统计 =====');
  console.log(`时间: ${new Date().toISOString().slice(11, 16)}`);

  // 打印高频手环统计（原有逻辑）
  console.log('\n高频手环(出现≥50次):');
  sortedMacs.filter(entry => entry.count >= 10).forEach((entry, index) => {
    console.log(`(${index + 1}) ${entry.mac}: ${entry.count}次, 平均RSSI: ${entry.avgRssi.toFixed(2)}`);
  });

  // 打印低频手环统计
  console.log(`\n低频手环(出现<10次): 共${lowFrequencyCount}个`);
  if (lowFrequencyCount > 0) {
    console.log('列表:', lowFrequencyMacs.join(', '));
  }

  // 打印历史低频趋势
  console.log('\n过去60分钟低频手环数量趋势:');
  console.log('时间\t数量');
  lowFrequencyStats.forEach(stat => {
    console.log(`${stat.minute}\t${stat.count}`);
  });

  console.log('===================\n');
}







